{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法\n",
    "\n",
    "DQN 经验回放的算法中的均匀采样算法，可能会忘记一些重要的、以后使用的经验数据。针对这样的问题，PER_DQN 提出了优先级经验回放（prioritized experience reolay）的技术来解决，这种方法应用到 DQN 获得了更好的效果。PER_DQN 成功的原因有：\n",
    "1. 提出了sum tree这样复杂度为O(logn)的高效数据结构\n",
    "2. 正确估计了 weighted importance sampling\n",
    "\n",
    "注意, 本Notebook的Buffer实现用的是简化的方式，想参考原论文sum tree的实现参考其他Notebook即可"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, n_states,n_actions,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "在实现上PER有两种方式，一个是简版PER，另一个就是接近原论文的SumTree PER，两者主要有以下不同：\n",
    "\n",
    "* 数据结构: 前者使用数组保存优先级，后者则用二叉树(SumTree)保存\n",
    "* 采样复杂度: 采样时前者是直接用概率分布随机，复杂度是 O(N)（慢）, 后者用树查找，复杂度是 O(log N)（快）\n",
    "* 更新优先级复杂度: 前者直接更新数组，O(1)（快）, 后者更新树上的节点，O(log N)（稍慢，但可以承受）\n",
    "* 内存开销: 小（1个数组）, 后者略大（1棵树 + 1个数据数组）\n",
    "* 适合场景： 小 buffer（比如几千条数据以内）, 大 buffer（比如一万到几十万条数据）\n",
    "\n",
    "我们仅在此Notebook上实现简版的PER, 其余默认使用SumTree PER\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, cfg):\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.alpha = cfg.per_alpha\n",
    "        self.beta = cfg.per_beta\n",
    "        self.beta_increment_per_sampling = cfg.per_beta_increment_per_sampling\n",
    "        self.buffer = []\n",
    "        self.pos = 0\n",
    "        self.priorities = np.zeros((self.capacity,), dtype=np.float32)\n",
    "\n",
    "    def push(self, transition):\n",
    "        max_prio = self.priorities.max() if self.buffer else 1.0\n",
    "        if len(self.buffer) < self.capacity:\n",
    "            self.buffer.append(transition)\n",
    "        else:\n",
    "            self.buffer[self.pos] = transition\n",
    "        self.priorities[self.pos] = max_prio\n",
    "        self.pos = (self.pos + 1) % self.capacity\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        self.beta = min(1.0, self.beta + self.beta_increment_per_sampling)\n",
    "        if len(self.buffer) == self.capacity:\n",
    "            prios = self.priorities\n",
    "        else:\n",
    "            prios = self.priorities[:len(self.buffer)]\n",
    "\n",
    "        probs = prios ** self.alpha\n",
    "        probs /= probs.sum()\n",
    "\n",
    "        indices = np.random.choice(len(self.buffer), batch_size, p=probs)\n",
    "        samples = [self.buffer[idx] for idx in indices]\n",
    "\n",
    "        total = len(self.buffer)\n",
    "        weights = (total * probs[indices]) ** (-self.beta)\n",
    "        weights /= weights.max()\n",
    "        weights = np.array(weights, dtype=np.float32)\n",
    "\n",
    "        batch = list(zip(*samples))\n",
    "        return tuple(map(lambda x: np.array(x), batch)), indices, weights\n",
    "\n",
    "    def update_priorities(self, indices, priorities):\n",
    "        for idx, prio in zip(indices, priorities):\n",
    "            self.priorities[idx] = prio\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg):\n",
    "        self.action_dim = cfg.action_dim  # 动作空间的维度\n",
    "        self.device = torch.device(cfg.device) # CPU或GPU \n",
    "        self.gamma = cfg.gamma  # 奖励的折扣因子\n",
    "        ## e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "        # 当前网络和目标网络\n",
    "        self.model = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_model = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # # 复制参数到目标网络\n",
    "        # for target_param, param in zip(self.target_model.parameters(),self.model.parameters()): \n",
    "        #     target_param.data.copy_(param.data)\n",
    "        self.target_model.load_state_dict(self.model.state_dict()) # 复制参数到目标网络\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr) \n",
    "        self.memory = ReplayBuffer(cfg) # 经验回放\n",
    "        self.update_cnt = 0\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' sample action with e-greedy policy\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon 指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            action = self.predict_action(state) # 预测动作\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim) # 随机动作, 便于前期探索\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0) # [1, state_dim]\n",
    "        q_values = self.model(state)\n",
    "        action = q_values.max(1)[1].item() \n",
    "        return action\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        ''' 获取当前策略的参数\n",
    "        '''\n",
    "        return self.model.state_dict()\n",
    "    \n",
    "    def load_policy_params(self, params):\n",
    "        ''' 加载策略参数\n",
    "        '''\n",
    "        self.model.load_state_dict(params)\n",
    "    \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 采样一个batch\n",
    "        (states, actions, rewards, next_states, dones), idxs, weights = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [B, state_dim]]\n",
    "        actions = torch.tensor(actions, device=self.device, dtype=torch.int64).unsqueeze(1) # [B,1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1) # [B,1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [B, state_dim]]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1) # [B,1]\n",
    "        weights = torch.tensor(weights, device=self.device, dtype=torch.float).unsqueeze(1) # [B,1]\n",
    "\n",
    "        q_value = self.model(states).gather(dim=1, index=actions) # [B,1]\n",
    "        next_q_value_max = self.target_model(next_states).max(1)[0].detach().unsqueeze(1) \n",
    "        expected_q_value = rewards + self.gamma * next_q_value_max* (1-dones)\n",
    "        td_errors = abs(q_value - expected_q_value)\n",
    "\n",
    "        # loss中根据优先度进行了加权\n",
    "        loss = (td_errors ** 2 * weights).mean()\n",
    "\n",
    "        priorities = td_errors.squeeze().cpu().detach().numpy() + 1e-5 # 计算TD误差\n",
    "        # 需要更新样本的优先度\n",
    "        self.memory.update_priorities(idxs, priorities) \n",
    "\n",
    "        # 反向传播\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # 梯度截断，防止梯度爆炸\n",
    "        for param in self.model.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        if self.update_cnt % self.target_update == 0: # 更新 target_model\n",
    "            self.target_model.load_state_dict(self.model.state_dict()) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置参数和定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线, 类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'PER_DQN' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.max_epsiode = 200 # 训练的回合数\n",
    "        self.max_epsiode_test = 20 # 测试的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 500 # e-greedy策略中epsilon的衰减率\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        #region buffer相关参数\n",
    "        self.buffer_size = 100000 # 经验回放池的容量\n",
    "        self.per_alpha = 0.6 # 优先级的指数 \n",
    "        self.per_beta = 0.4 # beta的初始值\n",
    "        self.per_beta_increment_per_sampling = 0.0001 # beta的增量\n",
    "        #endregion\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'\n",
    "        self.reward_threshold = 200 # 奖励阈值，达到该值则认为训练成功\n",
    "        self.reward_threshold_limit = 10 # 累计一定训练成功次数后停止训练, 这样可以避免训练过长时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def make_env(cfg: Config):\n",
    "    ''' 创建环境\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id) # 创建环境\n",
    "    setattr(cfg, \"action_space\", env.action_space) # 动作空间\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0]) # 状态维度\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n) # 动作维度\n",
    "    return env\n",
    "\n",
    "def train(cfg: Config, env, policy):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    reward_threshold_cnt = 0 # 奖励阈值计数器\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, float(truncated or terminated)))   # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                if ep_reward >= best_ep_reward:  # 更新最佳策略\n",
    "                    best_ep_reward = ep_reward\n",
    "                    best_policy_params = policy.model.state_dict()\n",
    "                    print(f\"更新最佳策略，回合：{i_ep+1}/{cfg.max_epsiode},  最佳奖励：{best_ep_reward:.2f}\")\n",
    "                if ep_reward >= cfg.reward_threshold:\n",
    "                    reward_threshold_cnt += 1\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if reward_threshold_cnt >= cfg.reward_threshold_limit:\n",
    "            print(f\"达到奖励阈值累计{cfg.reward_threshold_limit}次, 训练成功，回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}\")\n",
    "            break\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}, Epislon: {policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames, 'best_policy_params':best_policy_params} # 返回训练结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t      PER_DQN       \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "    max_epsiode     \t        200         \t   <class 'int'>    \n",
      "  max_epsiode_test  \t         20         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        500         \t   <class 'int'>    \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "  reward_threshold  \t        200         \t   <class 'int'>    \n",
      "reward_threshold_limit\t         10         \t   <class 'int'>    \n",
      "     state_dim      \t         4          \t   <class 'int'>    \n",
      "================================================================================\n",
      "更新最佳策略，回合：1/200，奖励：18.00\n",
      "更新最佳策略，回合：2/200，奖励：28.00\n",
      "更新最佳策略，回合：5/200，奖励：31.00\n",
      "更新最佳策略，回合：9/200，奖励：31.00\n",
      "回合：10/200，奖励：22.00, Epislon: 0.613\n",
      "回合：20/200，奖励：14.00, Epislon: 0.476\n",
      "回合：30/200，奖励：9.00, Epislon: 0.371\n",
      "回合：40/200，奖励：11.00, Epislon: 0.300\n",
      "回合：50/200，奖励：10.00, Epislon: 0.235\n",
      "更新最佳策略，回合：56/200，奖励：43.00\n",
      "更新最佳策略，回合：60/200，奖励：44.00\n",
      "回合：60/200，奖励：44.00, Epislon: 0.148\n",
      "更新最佳策略，回合：61/200，奖励：49.00\n",
      "更新最佳策略，回合：63/200，奖励：49.00\n",
      "更新最佳策略，回合：64/200，奖励：54.00\n",
      "更新最佳策略，回合：68/200，奖励：57.00\n",
      "更新最佳策略，回合：69/200，奖励：59.00\n",
      "更新最佳策略，回合：70/200，奖励：77.00\n",
      "回合：70/200，奖励：77.00, Epislon: 0.060\n",
      "更新最佳策略，回合：71/200，奖励：140.00\n",
      "更新最佳策略，回合：72/200，奖励：141.00\n",
      "更新最佳策略，回合：73/200，奖励：188.00\n",
      "回合：80/200，奖励：200.00, Epislon: 0.011\n",
      "回合：90/200，奖励：200.00, Epislon: 0.010\n",
      "回合：100/200，奖励：200.00, Epislon: 0.010\n",
      "回合：110/200，奖励：200.00, Epislon: 0.010\n",
      "回合：120/200，奖励：200.00, Epislon: 0.010\n",
      "回合：130/200，奖励：200.00, Epislon: 0.010\n",
      "回合：140/200，奖励：200.00, Epislon: 0.010\n",
      "回合：150/200，奖励：200.00, Epislon: 0.010\n",
      "回合：160/200，奖励：200.00, Epislon: 0.010\n",
      "回合：170/200，奖励：200.00, Epislon: 0.010\n",
      "回合：180/200，奖励：200.00, Epislon: 0.010\n",
      "回合：190/200，奖励：200.00, Epislon: 0.010\n",
      "回合：200/200，奖励：200.00, Epislon: 0.010\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "env = make_env(cfg) # 创建环境\n",
    "policy = Policy(cfg)\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg,env,policy) # 训练\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 策略测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def test(cfg, env, policy: Policy):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.max_epsiode_test):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.max_epsiode_test}，奖励：{ep_reward:.2f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n",
    "test_env = make_env(cfg)\n",
    "test_policy = Policy(cfg)\n",
    "test_policy.load_policy_params(res['best_policy_params']) # 加载训练时的最佳策略参数\n",
    "test_res = test(cfg, test_env, test_policy)\n",
    "plot_rewards(cfg, test_res['frames'], test_res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
